home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / plan / src / weekmenu.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  11KB  |  369 lines
  1. /*
  2.  * week menu widgets.
  3.  *
  4.  *    destroy_week_menu()        remove week menu
  5.  *    create_week_menu()        Create all widgets in week calendar
  6.  *                    window.
  7.  */
  8.  
  9. #ifndef MIPS
  10. #include <stdlib.h>
  11. #endif
  12. #include <stdio.h>
  13. #include <time.h>
  14. #include <varargs.h>
  15. #include <Xm/Xm.h>
  16. #include <Xm/DialogS.h>
  17. #include <Xm/Form.h>
  18. #include <Xm/Frame.h>
  19. #include <Xm/RowColumn.h>
  20. #include <Xm/LabelP.h>
  21. #include <Xm/ArrowBP.h>
  22. #include <Xm/ArrowBG.h>
  23. #include <Xm/PushBP.h>
  24. #include <Xm/PushBG.h>
  25. #include <Xm/Text.h>
  26. #include <Xm/ScrolledW.h>
  27. #include <Xm/DrawingA.h>
  28. #include <Xm/Protocols.h>
  29. #include "cal.h"
  30.  
  31. static void done_callback(), user_callback(), edit_callback(), sync_callback();
  32. static void week_callback(), prev_callback(), next_callback();
  33. extern void help_callback();
  34. extern time_t length_of_month();
  35. extern struct tm *time_to_tm();
  36.  
  37. extern Display        *display;    /* everybody uses the same server */
  38. extern struct config    config;        /* global configuration data */
  39. extern struct list    *mainlist;    /* list of all schedule entries */
  40. extern time_t        curr_week;    /* week being displayed, time in sec */
  41. extern struct week    week;        /* info on week view */
  42.  
  43. static BOOL        have_shell;    /* week window is being displayed */
  44. static Widget        shell;
  45.  
  46.  
  47. /*
  48.  * destroy the week menu. Remove it from the screen, and destroy its widgets.
  49.  */
  50.  
  51. destroy_week_menu()
  52. {
  53.     if (have_shell) {
  54.         XtPopdown(shell);
  55.         XTDESTROYWIDGET(shell);
  56.         destroy_week();
  57.         have_shell = FALSE;
  58.         week.canvas = 0;
  59.     }
  60. }
  61.  
  62.  
  63. /*
  64.  * create the week menu for the week beginning on curr_week.
  65.  */
  66.  
  67. create_week_menu()
  68. {
  69.     Arg        args[15];
  70.     int        n;
  71.     Widget        form, w;
  72.     Atom        closewindow;
  73.  
  74.     build_week();
  75.  
  76.     if (have_shell) {
  77.         resize_canvas(shell, week.scroll, week.canvas,
  78.                     week.canvas_xs, week.canvas_ys);
  79.         XtPopup(shell, XtGrabNone);
  80.         XRaiseWindow(display, XtWindow(shell));
  81.         redraw_week_calendar();
  82.         return;
  83.     }
  84.     n = 0;
  85.     XtSetArg(args[n], XmNdeleteResponse,    XmDO_NOTHING);        n++;
  86.     XtSetArg(args[n], XmNiconic,        False);            n++;
  87.     shell = XtAppCreateShell("Week View", "plan",
  88.             applicationShellWidgetClass, display, args, n);
  89. #    ifdef EDITRES
  90.     XtAddEventHandler(shell, (EventMask)0, TRUE, 
  91.              _XEditResCheckMessages, NULL);
  92. #    endif
  93.     set_icon(shell, 0);
  94.  
  95.     form = XtCreateWidget("weekform", xmFormWidgetClass,
  96.             shell, NULL, 0);
  97.     XtAddCallback(form, XmNhelpCallback, help_callback, (XtPointer)"week");
  98.  
  99.                             /*-- buttons --*/
  100.     n = 0;
  101.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  102.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  103.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  104.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  105.     XtSetArg(args[n], XmNwidth,        50);            n++;
  106.     w = XtCreateManagedWidget("Prev", xmPushButtonWidgetClass,
  107.             form, args, n);
  108.     XtAddCallback(w, XmNactivateCallback, prev_callback, (XtPointer)0);
  109.     XtAddCallback(w, XmNhelpCallback,     help_callback, (XtPointer)
  110.                                 "week_prev");
  111.     n = 0;
  112.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  113.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  114.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  115.     XtSetArg(args[n], XmNleftWidget,    w);            n++;
  116.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  117.     XtSetArg(args[n], XmNwidth,        50);            n++;
  118.     w = XtCreateManagedWidget("Next", xmPushButtonWidgetClass,
  119.             form, args, n);
  120.     XtAddCallback(w, XmNactivateCallback,next_callback, (XtPointer)0);
  121.     XtAddCallback(w, XmNhelpCallback,    help_callback, (XtPointer)
  122.                                 "week_next");
  123.  
  124.     n = 0;
  125.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  126.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  127.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  128.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  129.     XtSetArg(args[n], XmNwidth,        80);            n++;
  130.     w = XtCreateManagedWidget("Done", xmPushButtonWidgetClass,
  131.             form, args, n);
  132.     XtAddCallback(w, XmNactivateCallback, done_callback, (XtPointer)0);
  133.     XtAddCallback(w, XmNhelpCallback,     help_callback, (XtPointer)
  134.                                 "week_done");
  135.     n = 0;
  136.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  137.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  138.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);    n++;
  139.     XtSetArg(args[n], XmNrightWidget,    w);            n++;
  140.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  141.     XtSetArg(args[n], XmNwidth,        80);            n++;
  142.     w = XtCreateManagedWidget("Help", xmPushButtonWidgetClass,
  143.             form, args, n);
  144.     XtAddCallback(w, XmNactivateCallback,help_callback, (XtPointer)"week");
  145.     XtAddCallback(w, XmNhelpCallback,    help_callback, (XtPointer)"week");
  146.  
  147.     n = 0;
  148.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  149.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  150.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);    n++;
  151.     XtSetArg(args[n], XmNrightWidget,    w);            n++;
  152.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  153.     XtSetArg(args[n], XmNwidth,        80);            n++;
  154.     w = XtCreateManagedWidget("Users", xmPushButtonWidgetClass,
  155.             form, args, n);
  156.     XtAddCallback(w, XmNactivateCallback, user_callback, (XtPointer)0);
  157.     XtAddCallback(w, XmNhelpCallback,     help_callback, (XtPointer)
  158.                                 "week_user");
  159.  
  160.     n = 0;
  161.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  162.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  163.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);    n++;
  164.     XtSetArg(args[n], XmNrightWidget,    w);            n++;
  165.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  166.     XtSetArg(args[n], XmNwidth,        80);            n++;
  167.     w = XtCreateManagedWidget("Edit", xmPushButtonWidgetClass,
  168.             form, args, n);
  169.     XtAddCallback(w, XmNactivateCallback, edit_callback, (XtPointer)0);
  170.     XtAddCallback(w, XmNhelpCallback,     help_callback, (XtPointer)
  171.                                 "week_edit");
  172.  
  173.     n = 0;
  174.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  175.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  176.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);    n++;
  177.     XtSetArg(args[n], XmNrightWidget,    w);            n++;
  178.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  179.     XtSetArg(args[n], XmNwidth,        80);            n++;
  180.     w = XtCreateManagedWidget("Sync", xmPushButtonWidgetClass,
  181.             form, args, n);
  182.     XtAddCallback(w, XmNactivateCallback, sync_callback, (XtPointer)0);
  183.     XtAddCallback(w, XmNhelpCallback,     help_callback, (XtPointer)
  184.                                 "week_sync");
  185.  
  186.                             /*--- infotext --- */
  187.     n = 0;
  188.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  189.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  190.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  191.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  192.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_WIDGET);    n++;
  193.     XtSetArg(args[n], XmNbottomWidget,    w);            n++;
  194.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  195.     XtSetArg(args[n], XmNalignment,         XmALIGNMENT_BEGINNING);    n++;
  196.     week.info = XtCreateManagedWidget(" ", xmLabelWidgetClass,
  197.             form, args, n);
  198.  
  199.                             /*--- week view ---*/
  200.     n = 0;
  201.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  202.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  203.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_WIDGET);    n++;
  204.     XtSetArg(args[n], XmNbottomWidget,    week.info);        n++;
  205.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  206.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  207.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  208.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  209.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  210.     XtSetArg(args[n], XmNwidth,        week.canvas_xs +4);    n++;
  211.     XtSetArg(args[n], XmNheight,        week.canvas_ys +4);    n++;
  212.     XtSetArg(args[n], XmNscrollingPolicy,    XmAUTOMATIC);        n++;
  213.     week.scroll = XtCreateWidget("scroll", xmScrolledWindowWidgetClass,
  214.             form, args, n);
  215.  
  216.     n = 0;
  217.     XtSetArg(args[n], XmNwidth,        week.canvas_xs);    n++;
  218.     XtSetArg(args[n], XmNheight,        week.canvas_ys);    n++;
  219.     week.canvas = XtCreateWidget("weekcal", xmDrawingAreaWidgetClass,
  220.             week.scroll, args, n);
  221.     XtAddCallback(week.canvas, XmNinputCallback,
  222.                     week_callback, (XtPointer)NULL);
  223.     XtAddCallback(week.canvas, XmNexposeCallback,
  224.                     week_callback, (XtPointer)NULL);
  225.  
  226.     XtManageChild(week.canvas);
  227.     XtManageChild(week.scroll);
  228.     XtManageChild(form);
  229.  
  230.     XtPopup(shell, XtGrabNone);
  231.     closewindow = XmInternAtom(display, "WM_DELETE_WINDOW", False);
  232.     XmAddWMProtocolCallback(shell, closewindow,
  233.                     done_callback, (XtPointer)shell);
  234.     have_shell = TRUE;
  235. }
  236.  
  237.  
  238. /*
  239.  * resize a DrawingArea canvas, and resize the shell that contains it by
  240.  * the same amount. Also, resize the scrolling widget around the canvas.
  241.  * Make it a bit larger for the shadow.
  242.  */
  243.  
  244. resize_canvas(shell, scroll, canvas, xs, ys)
  245.     Widget        shell;        /* shell with the DrawingArea */
  246.     Widget        scroll;        /* scrolling area around canvas */
  247.     Widget        canvas;        /* DrawingArea */
  248.     int        xs, ys;        /* new DrawingArea size */
  249. {
  250.     Arg        args[2];
  251.     Dimension    sh_xs, sh_ys;    /* previous size of the shell */
  252.     Dimension    can_xs, can_ys;    /* previous size of the canvas */
  253.  
  254.     XtSetArg(args[0], XmNwidth,  &sh_xs);
  255.     XtSetArg(args[1], XmNheight, &sh_ys);
  256.     XtGetValues(shell, args, 2);
  257.  
  258.     XtSetArg(args[0], XmNwidth,  &can_xs);
  259.     XtSetArg(args[1], XmNheight, &can_ys);
  260.     XtGetValues(canvas, args, 2);
  261.  
  262.     XtSetArg(args[0], XmNwidth,  xs);
  263.     XtSetArg(args[1], XmNheight, ys);
  264.     XtSetValues(canvas, args, 2);
  265.  
  266.     XtSetArg(args[0], XmNwidth,  xs+4);
  267.     XtSetArg(args[1], XmNheight, ys+4);
  268.     XtSetValues(scroll, args, 2);
  269.  
  270.     XtSetArg(args[0], XmNwidth,  sh_xs - can_xs + xs);
  271.     XtSetArg(args[1], XmNheight, sh_ys - can_ys + ys);
  272.     XtSetValues(shell, args, 2);
  273. }
  274.  
  275.  
  276. /*-------------------------------------------------- callbacks --------------*/
  277. /*
  278.  * All of these routines are direct X callbacks.
  279.  */
  280.  
  281. /*ARGSUSED*/
  282. static void prev_callback(widget, item, data)
  283.     Widget                widget;
  284.     int                item;
  285.     XmToggleButtonCallbackStruct    *data;
  286. {
  287.     struct tm *tm = time_to_tm(curr_week);
  288.     if (tm->tm_yday > 6) {
  289.         curr_week -= 7*86400;
  290.         draw_week_calendar();
  291.     }
  292. }
  293.  
  294.  
  295. /*ARGSUSED*/
  296. static void next_callback(widget, item, data)
  297.     Widget                widget;
  298.     int                item;
  299.     XmToggleButtonCallbackStruct    *data;
  300. {
  301.     struct tm *tm = time_to_tm(curr_week);
  302.     if (tm->tm_yday < 365-6) {
  303.         curr_week += 7*86400;
  304.         draw_week_calendar();
  305.     }
  306. }
  307.  
  308.  
  309. /*ARGSUSED*/
  310. static void done_callback(widget, item, data)
  311.     Widget                widget;
  312.     int                item;
  313.     XmToggleButtonCallbackStruct    *data;
  314. {
  315.     destroy_week_menu();
  316. }
  317.  
  318.  
  319. /*ARGSUSED*/
  320. static void user_callback(widget, item, data)
  321.     Widget                widget;
  322.     int                item;
  323.     XmToggleButtonCallbackStruct    *data;
  324. {
  325.     create_user_popup();
  326. }
  327.  
  328.  
  329. /*ARGSUSED*/
  330. static void edit_callback(widget, item, data)
  331.     Widget                widget;
  332.     int                item;
  333.     XmToggleButtonCallbackStruct    *data;
  334. {
  335.     create_list_popup(mainlist, curr_week, NDAYS*86400,
  336.                     0, (struct entry *)0);
  337. }
  338.  
  339.  
  340. /*ARGSUSED*/
  341. static void sync_callback(widget, item, data)
  342.     Widget                widget;
  343.     int                item;
  344.     XmToggleButtonCallbackStruct    *data;
  345. {
  346.     force_user_list_update();
  347.     draw_week_calendar();
  348. }
  349.  
  350.  
  351. /*ARGSUSED*/
  352. static void week_callback(w, data, info)
  353.     Widget                w;
  354.     XtPointer            data;
  355.     XmDrawingAreaCallbackStruct    *info;
  356. {
  357.     if (info->reason == XmCR_INPUT && info->event->xany.type ==ButtonPress)
  358.         clicked_week_calendar(info->event->xbutton.x,
  359.                       info->event->xbutton.y,
  360.                       info->event->xbutton.time);
  361.  
  362.     else if (info->reason == XmCR_EXPOSE) {
  363.         XEvent dummy;
  364.         while (XCheckWindowEvent(display, info->window, ExposureMask,
  365.                                 &dummy));
  366.         redraw_week_calendar();
  367.     }
  368. }
  369.